TypeScript Node.js: சேவையகப் பக்க வகை பாதுகாப்பு செயலாக்கம்

வலை மேம்பாட்டின் எப்போதும் மாறிவரும் நிலப்பரப்பில், வலுவான மற்றும் பராமரிக்கக்கூடிய சேவையகப் பக்க பயன்பாடுகளை உருவாக்குவது மிக முக்கியமானது. JavaScript நீண்ட காலமாக இணையத்தின் மொழியாக இருந்து வந்தாலும், அதன் மாறும் இயல்பு சில நேரங்களில் இயக்க நேர பிழைகள் மற்றும் பெரிய திட்டங்களை அளவிடுவதில் சிரமங்களுக்கு வழிவகுக்கும். நிலையான தட்டச்சு சேர்க்கும் JavaScript இன் மிகை தொகுப்பான TypeScript, இந்த சவால்களுக்கு ஒரு சக்திவாய்ந்த தீர்வை வழங்குகிறது. TypeScript உடன் Node.js ஐ இணைப்பது, வகை-பாதுகாப்பான, அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய பின்தள அமைப்புகளை உருவாக்குவதற்கான ஒரு கட்டாய சூழலை வழங்குகிறது.

Node.js சேவையகப் பக்க மேம்பாட்டிற்கான TypeScript ஏன்?

JavaScript இன் மாறும் தட்டச்சில் உள்ளார்ந்த பல வரம்படுகளை நிவர்த்தி செய்து, TypeScript Node.js மேம்பாட்டிற்கு ஏராளமான நன்மைகளை அளிக்கிறது.

• மேம்படுத்தப்பட்ட வகை பாதுகாப்பு: TypeScript தொகுக்கும் நேரத்தில் கடுமையான வகை சரிபார்ப்பை செயல்படுத்துகிறது, அவை உற்பத்திக்கு வருவதற்கு முன்பு சாத்தியமான பிழைகளை பிடிக்கிறது. இது இயக்க நேர விதிவிலக்குகளின் அபாயத்தைக் குறைக்கிறது மற்றும் உங்கள் பயன்பாட்டின் ஒட்டுமொத்த ஸ்திரத்தன்மையை மேம்படுத்துகிறது. உங்கள் API ஒரு பயனர் ஐடியை எண்ணாக எதிர்பார்க்கும் ஆனால் ஒரு சரத்தைப் பெறும் ஒரு சூழ்நிலையை கற்பனை செய்து பாருங்கள். TypeScript இந்த பிழையை மேம்பாட்டின் போது கொடியிடும், உற்பத்தியில் ஏற்படக்கூடிய செயலிழப்பைத் தடுக்கும்.
• மேம்படுத்தப்பட்ட குறியீடு பராமரிப்பு: வகை சிறுகுறிப்புகள் குறியீட்டைப் புரிந்துகொள்வதையும் மறுசீரமைப்பதையும் எளிதாக்குகின்றன. ஒரு குழுவில் பணிபுரியும் போது, தெளிவான வகை வரையறைகள் டெவலப்பர்கள் குறியீட்டு தளத்தின் வெவ்வேறு பகுதிகளின் நோக்கம் மற்றும் எதிர்பார்க்கப்படும் நடத்தையை விரைவாகப் புரிந்து கொள்ள உதவுகின்றன. வளர்ந்து வரும் தேவைகளுடன் நீண்ட கால திட்டங்களுக்கு இது மிகவும் முக்கியமானது.
• மேம்படுத்தப்பட்ட IDE ஆதரவு: TypeScript இன் நிலையான தட்டச்சு IDEகள் (ஒருங்கிணைந்த மேம்பாட்டு சூழல்கள்) சிறந்த தானியங்கு நிரப்புதல், குறியீடு வழிசெலுத்தல் மற்றும் மறுசீரமைப்பு கருவிகளை வழங்க உதவுகிறது. இது டெவலப்பர் உற்பத்தித்திறனை கணிசமாக மேம்படுத்துகிறது மற்றும் பிழைகள் ஏற்படுவதற்கான வாய்ப்புகளை குறைக்கிறது. உதாரணமாக, VS Code இன் TypeScript ஒருங்கிணைப்பு அறிவார்ந்த ஆலோசனைகளையும் பிழை சிறப்பம்சங்களையும் வழங்குகிறது, இது மேம்பாட்டை வேகமாகவும் திறமையாகவும் செய்கிறது.
• ஆரம்ப பிழை கண்டறிதல்: தொகுப்பின் போது வகை தொடர்பான பிழைகளை அடையாளம் காண்பதன் மூலம், TypeScript மேம்பாட்டு சுழற்சியின் ஆரம்பத்தில் சிக்கல்களை சரிசெய்ய உங்களை அனுமதிக்கிறது, நேரத்தை மிச்சப்படுத்துகிறது மற்றும் பிழைத்திருத்த முயற்சிகளை குறைக்கிறது. இந்த செயலூக்கமான அணுகுமுறை பயன்பாட்டின் மூலம் பிழைகள் பரவுவதையும் பயனர்களை பாதிப்பதையும் தடுக்கிறது.
• படிப்படியான தத்தெடுப்பு: TypeScript என்பது JavaScript இன் ஒரு மிகை தொகுப்பாகும், அதாவது ஏற்கனவே உள்ள JavaScript குறியீட்டை படிப்படியாக TypeScript க்கு மாற்ற முடியும். இது உங்கள் குறியீட்டு தளத்தை முழுமையாக மீண்டும் எழுதத் தேவையில்லாமல், வகை பாதுகாப்பை படிப்படியாக அறிமுகப்படுத்த உங்களை அனுமதிக்கிறது.

TypeScript Node.js திட்டத்தை அமைத்தல்

TypeScript மற்றும் Node.js உடன் தொடங்க, நீங்கள் Node.js மற்றும் npm (Node Package Manager) ஐ நிறுவ வேண்டும். நீங்கள் அவற்றை நிறுவியதும், புதிய திட்டத்தை அமைக்க இந்த படிகளைப் பின்பற்றலாம்:

1. ஒரு திட்ட அடைவை உருவாக்கவும்: உங்கள் திட்டத்திற்கான புதிய அடைவை உருவாக்கி, உங்கள் டெர்மினலில் அதற்குள் செல்லவும்.
2. Node.js திட்டத்தைத் தொடங்கவும்: package.json கோப்பை உருவாக்க npm init -y ஐ இயக்கவும்.
3. TypeScript ஐ நிறுவவும்: TypeScript மற்றும் Node.js வகை வரையறைகளை நிறுவ npm install --save-dev typescript @types/node ஐ இயக்கவும். @types/node தொகுப்பு Node.js உள்ளமைக்கப்பட்ட தொகுதிகளுக்கான வகை வரையறைகளை வழங்குகிறது, இது TypeScript உங்கள் Node.js குறியீட்டைப் புரிந்துகொண்டு சரிபார்க்க அனுமதிக்கிறது.
4. TypeScript உள்ளமைவு கோப்பை உருவாக்கவும்: tsconfig.json கோப்பை உருவாக்க npx tsc --init ஐ இயக்கவும். இந்த கோப்பு TypeScript கம்பைலரை உள்ளமைத்து தொகுப்பு விருப்பங்களை குறிப்பிடுகிறது.
5. tsconfig.json ஐ உள்ளமைக்கவும்: உங்கள் திட்டத்தின் தேவைகளுக்கு ஏற்ப tsconfig.json கோப்பைத் திறந்து அதை உள்ளமைக்கவும். சில பொதுவான விருப்பங்கள் பின்வருமாறு:
• target: ECMAScript இலக்கு பதிப்பை குறிப்பிடுகிறது (எ.கா., "es2020", "esnext").
• module: பயன்படுத்த வேண்டிய தொகுதி அமைப்பை குறிப்பிடுகிறது (எ.கா., "commonjs", "esnext").
• outDir: தொகுக்கப்பட்ட JavaScript கோப்புகளுக்கான வெளியீட்டு அடைவை குறிப்பிடுகிறது.
• rootDir: TypeScript மூலக் கோப்புகளுக்கான ரூட் அடைவை குறிப்பிடுகிறது.
• sourceMap: எளிதாக பிழைத்திருத்துவதற்கு மூல வரைபட உருவாக்கத்தை இயக்குகிறது.
• strict: கடுமையான வகை சரிபார்ப்பை இயக்குகிறது.
• esModuleInterop: CommonJS மற்றும் ES தொகுதிகளுக்கு இடையிலான இயங்குதன்மையை இயக்குகிறது.

மாதிரி tsconfig.json கோப்பு இப்படி இருக்கலாம்:

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": [
    "src/**/*"
  ]
}

இந்த உள்ளமைவு TypeScript கம்பைலரிடம் src அடைவில் உள்ள அனைத்து .ts கோப்புகளையும் தொகுக்கச் சொல்கிறது, தொகுக்கப்பட்ட JavaScript கோப்புகளை dist அடைவுக்கு வெளியிடுகிறது மற்றும் பிழைத்திருத்தத்திற்கான மூல வரைபடங்களை உருவாக்குகிறது.

அடிப்படை வகை சிறுகுறிப்புகள் மற்றும் இடைமுகங்கள்

TypeScript வகை சிறுகுறிப்புகளை அறிமுகப்படுத்துகிறது, இது மாறிகள், செயல்பாடு அளவுருக்கள் மற்றும் திரும்பும் மதிப்புகளின் வகைகளை வெளிப்படையாகக் குறிப்பிட உங்களை அனுமதிக்கிறது. இது வகை சரிபார்ப்பை செய்து பிழைகளை ஆரம்பத்தில் பிடிக்க TypeScript கம்பைலரை செயல்படுத்துகிறது.

அடிப்படை வகைகள்

TypeScript பின்வரும் அடிப்படை வகைகளை ஆதரிக்கிறது:

• string: உரை மதிப்புகளைக் குறிக்கிறது.
• number: எண் மதிப்புகளைக் குறிக்கிறது.
• boolean: பூலியன் மதிப்புகளைக் குறிக்கிறது (true அல்லது false).
• null: ஒரு மதிப்பின் வேண்டுமென்றே இல்லாததை குறிக்கிறது.
• undefined: ஒரு மதிப்பு ஒதுக்கப்படாத ஒரு மாறியைக் குறிக்கிறது.
• symbol: ஒரு தனித்துவமான மற்றும் மாற்ற முடியாத மதிப்பை குறிக்கிறது.
• bigint: தன்னிச்சையான துல்லியமான முழு எண்களைக் குறிக்கிறது.
• any: எந்த வகையின் மதிப்பையும் குறிக்கிறது (அரிதாக பயன்படுத்தவும்).
• unknown: எந்த வகையின் மதிப்பையும் குறிக்கிறது (any ஐ விட பாதுகாப்பானது).
• void: ஒரு செயல்பாட்டிலிருந்து திரும்பும் மதிப்பு இல்லாததை குறிக்கிறது.
• never: ஒருபோதும் ஏற்படாத ஒரு மதிப்பைக் குறிக்கிறது (எ.கா., எப்போதும் பிழையை எறியும் ஒரு செயல்பாடு).
• array: ஒரே வகையின் மதிப்புகளின் வரிசைப்படுத்தப்பட்ட சேகரிப்பைக் குறிக்கிறது (எ.கா., string[], number[]).
• tuple: குறிப்பிட்ட வகைகளுடன் மதிப்புகளின் வரிசைப்படுத்தப்பட்ட சேகரிப்பைக் குறிக்கிறது (எ.கா., [string, number]).
• enum: பெயரிடப்பட்ட மாறிலிகளின் தொகுப்பைக் குறிக்கிறது.
• object: ஒரு பழமையான அல்லாத வகையை குறிக்கிறது.

வகை சிறுகுறிப்புகளின் சில எடுத்துக்காட்டுகள் இங்கே:

let name: string = "John Doe";
let age: number = 30;
let isStudent: boolean = false;

function greet(name: string): string {
  return `Hello, ${name}!`;
}

let numbers: number[] = [1, 2, 3, 4, 5];

let person: { name: string; age: number } = {
  name: "Jane Doe",
  age: 25,
};

இடைமுகங்கள்

இடைமுகங்கள் ஒரு பொருளின் கட்டமைப்பை வரையறுக்கின்றன. அவை ஒரு பொருள் கொண்டிருக்க வேண்டிய பண்புகளையும் முறைகளையும் குறிப்பிடுகின்றன. வகை பாதுகாப்பை செயல்படுத்தவும் குறியீடு பராமரிப்பை மேம்படுத்தவும் இடைமுகங்கள் ஒரு சக்திவாய்ந்த வழியாகும்.

ஒரு இடைமுகத்தின் எடுத்துக்காட்டு இங்கே:

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
}

function getUser(id: number): User {
  // ... தரவுத்தளத்திலிருந்து பயனர் தரவைப் பெறுக
  return {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com",
    isActive: true,
  };
}

let user: User = getUser(1);

console.log(user.name); // John Doe

இந்த எடுத்துக்காட்டில், User இடைமுகம் ஒரு பயனர் பொருளின் கட்டமைப்பை வரையறுக்கிறது. getUser செயல்பாடு User இடைமுகத்திற்கு இணங்கும் ஒரு பொருளை வழங்குகிறது. இந்த செயல்பாடு இடைமுகத்துடன் பொருந்தாத ஒரு பொருளை வழங்கினால், TypeScript கம்பைலர் ஒரு பிழையை வீசும்.

வகை புனைப்பெயர்கள்

வகை புனைப்பெயர்கள் ஒரு வகைக்கு ஒரு புதிய பெயரை உருவாக்குகின்றன. அவை ஒரு புதிய வகையை உருவாக்கவில்லை - அவை இருக்கும் ஒரு வகைக்கு மிகவும் விளக்கமான அல்லது வசதியான பெயரை வழங்குகின்றன.

type StringOrNumber = string | number;

let value: StringOrNumber = "hello";
value = 123;

//ஒரு சிக்கலான பொருளுக்கான வகை புனைப்பெயர்
type Point = {
 x: number;
 y: number;
};

const myPoint: Point = { x: 10, y: 20 };

TypeScript மற்றும் Node.js உடன் ஒரு எளிய API ஐ உருவாக்குதல்

TypeScript, Node.js மற்றும் Express.js ஐப் பயன்படுத்தி ஒரு எளிய REST API ஐ உருவாக்குவோம்.

1. Express.js மற்றும் அதன் வகை வரையறைகளை நிறுவவும்: npm install express @types/express ஐ இயக்கவும்
2. பின்வரும் குறியீட்டுடன் src/index.ts எனப்படும் கோப்பை உருவாக்கவும்:

import express, { Request, Response } from 'express';

const app = express();
const port = process.env.PORT || 3000;

interface Product {
  id: number;
  name: string;
  price: number;
}

const products: Product[] = [
  { id: 1, name: 'லேப்டாப்', price: 1200 },
  { id: 2, name: 'விசைப்பலகை', price: 75 },
  { id: 3, name: 'சுட்டி', price: 25 },
];

app.get('/products', (req: Request, res: Response) => {
  res.json(products);
});

app.get('/products/:id', (req: Request, res: Response) => {
  const productId = parseInt(req.params.id);
  const product = products.find(p => p.id === productId);

  if (product) {
    res.json(product);
  } else {
    res.status(404).json({ message: 'தயாரிப்பு கிடைக்கவில்லை' });
  }
});

app.listen(port, () => {
  console.log(`சேவையகம் ${port} போர்ட்டில் இயங்குகிறது`);
});

இந்த குறியீடு இரண்டு இறுதிப் புள்ளிகளுடன் ஒரு எளிய Express.js API ஐ உருவாக்குகிறது:

• /products: தயாரிப்புகளின் பட்டியலை வழங்குகிறது.
• /products/:id: ஐடி மூலம் ஒரு குறிப்பிட்ட தயாரிப்பை வழங்குகிறது.

Product இடைமுகம் ஒரு தயாரிப்பு பொருளின் கட்டமைப்பை வரையறுக்கிறது. products வரிசையில் Product இடைமுகத்திற்கு இணங்கும் தயாரிப்பு பொருட்களின் பட்டியல் உள்ளது.

API ஐ இயக்க, நீங்கள் TypeScript குறியீட்டை தொகுத்து Node.js சேவையகத்தைத் தொடங்க வேண்டும்:

1. TypeScript குறியீட்டை தொகுக்கவும்: npm run tsc ஐ இயக்கவும் (package.json இல் இந்த ஸ்கிரிப்டை "tsc": "tsc" ஆக வரையறுக்க வேண்டியிருக்கலாம்).
2. Node.js சேவையகத்தைத் தொடங்கவும்: node dist/index.js ஐ இயக்கவும்.

பின்னர் உங்கள் உலாவியில் அல்லது curl போன்ற கருவி மூலம் API இறுதிப் புள்ளிகளை அணுகலாம்:

curl http://localhost:3000/products
curl http://localhost:3000/products/1

சேவையகப் பக்க மேம்பாட்டிற்கான மேம்பட்ட TypeScript நுட்பங்கள்

சேவையகப் பக்க மேம்பாட்டில் வகை பாதுகாப்பு மற்றும் குறியீடு தரத்தை மேலும் மேம்படுத்தக்கூடிய பல மேம்பட்ட அம்சங்களை TypeScript வழங்குகிறது.

பொதுவானவை

வகை பாதுகாப்பை தியாகம் செய்யாமல் வெவ்வேறு வகைகளுடன் வேலை செய்யக்கூடிய குறியீட்டை எழுத பொதுவானவை உங்களை அனுமதிக்கின்றன. அவை வகைகளை அளவுருப்படுத்துவதற்கான ஒரு வழியை வழங்குகின்றன, இது உங்கள் குறியீட்டை மேலும் மறுபயன்பாட்டு மற்றும் நெகிழ்வானதாக ஆக்குகிறது.

ஒரு பொதுவான செயல்பாட்டின் எடுத்துக்காட்டு இங்கே:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);

இந்த எடுத்துக்காட்டில், identity செயல்பாடு T வகையின் ஒரு வாதத்தை எடுத்து அதே வகையின் மதிப்பை வழங்குகிறது. <T> தொடரியல் T ஒரு வகை அளவுரு என்பதைக் குறிக்கிறது. நீங்கள் செயல்பாட்டை அழைக்கும்போது, T வகையை வெளிப்படையாகக் குறிப்பிடலாம் (எ.கா., identity<string>) அல்லது வாதத்திலிருந்து TypeScript அதை ஊகிக்க அனுமதிக்கலாம் (எ.கா., identity("hello")).

வேறுபடுத்தப்பட்ட சங்கங்கள்

குறியிடப்பட்ட சங்கங்கள் என்றும் அழைக்கப்படும் வேறுபடுத்தப்பட்ட சங்கங்கள், பல வெவ்வேறு வகைகளில் ஒன்றாக இருக்கக்கூடிய மதிப்புகளைக் குறிக்க ஒரு சக்திவாய்ந்த வழியாகும். அவை பெரும்பாலும் மாநில இயந்திரங்களை மாதிரியாகக் காட்ட அல்லது வெவ்வேறு வகையான பிழைகளைக் குறிக்கப் பயன்படுகின்றன.

வேறுபடுத்தப்பட்ட சங்கத்தின் எடுத்துக்காட்டு இங்கே:

type Success = {
  status: 'வெற்றி';
  data: any;
};

type Error = {
  status: 'பிழை';
  message: string;
};

type Result = Success | Error;

function handleResult(result: Result) {
  if (result.status === 'வெற்றி') {
    console.log('வெற்றி:', result.data);
  } else {
    console.error('பிழை:', result.message);
  }
}

const successResult: Success = { status: 'வெற்றி', data: { name: 'John Doe' } };
const errorResult: Error = { status: 'பிழை', message: 'ஏதோ தவறு நடந்தது' };

handleResult(successResult);
handleResult(errorResult);

இந்த எடுத்துக்காட்டில், Result வகை Success மற்றும் Error வகைகளின் வேறுபடுத்தப்பட்ட சங்கம். status சொத்து வேறுபடுத்தி, இது மதிப்பை எந்த வகை என்பதைக் குறிக்கிறது. handleResult செயல்பாடு மதிப்பை எவ்வாறு கையாள்வது என்பதைத் தீர்மானிக்க வேறுபடுத்தியைப் பயன்படுத்துகிறது.

பயன்பாட்டு வகைகள்

TypeScript பல உள்ளமைக்கப்பட்ட பயன்பாட்டு வகைகளை வழங்குகிறது, அவை வகைகளை கையாளவும், சுருக்கமான மற்றும் வெளிப்படையான குறியீட்டை உருவாக்கவும் உதவும். பொதுவாகப் பயன்படுத்தப்படும் சில பயன்பாட்டு வகைகள் பின்வருமாறு:

• Partial<T>: T இன் அனைத்து பண்புகளையும் விருப்பமானதாக ஆக்குகிறது.
• Required<T>: T இன் அனைத்து பண்புகளையும் கட்டாயமாக்குகிறது.
• Readonly<T>: T இன் அனைத்து பண்புகளையும் படிக்க மட்டும் ஆக்குகிறது.
• Pick<T, K>: T இன் பண்புகளுடன் மட்டுமே ஒரு புதிய வகையை உருவாக்குகிறது, அதன் விசைகள் K இல் உள்ளன.
• Omit<T, K>: T இன் அனைத்து பண்புகளுடனும் ஒரு புதிய வகையை உருவாக்குகிறது, அவற்றின் விசைகள் K இல் உள்ளவற்றைத் தவிர.
• Record<K, T>: K வகையின் விசைகள் மற்றும் T வகையின் மதிப்புகளுடன் ஒரு புதிய வகையை உருவாக்குகிறது.
• Exclude<T, U>: T இலிருந்து U க்கு ஒதுக்கக்கூடிய அனைத்து வகைகளையும் விலக்குகிறது.
• Extract<T, U>: T இலிருந்து U க்கு ஒதுக்கக்கூடிய அனைத்து வகைகளையும் பிரித்தெடுக்கிறது.
• NonNullable<T>: T இலிருந்து null மற்றும் undefined ஐ விலக்குகிறது.
• Parameters<T>: ஒரு செயல்பாடு வகை T இன் அளவுருக்களை ஒரு கோவையாகப் பெறுகிறது.
• ReturnType<T>: ஒரு செயல்பாடு வகை T இன் திரும்பும் வகையைப் பெறுகிறது.
• InstanceType<T>: ஒரு கன்ஸ்ட்ரக்டர் செயல்பாடு வகை T இன் நிகழ்வு வகையைப் பெறுகிறது.

பயன்பாட்டு வகைகளை எவ்வாறு பயன்படுத்துவது என்பதற்கான சில எடுத்துக்காட்டுகள் இங்கே:

interface User {
  id: number;
  name: string;
  email: string;
}

// பயனரின் அனைத்து பண்புகளையும் விருப்பமானதாக ஆக்குங்கள்
type PartialUser = Partial<User>;

// பயனரின் பெயர் மற்றும் மின்னஞ்சல் பண்புகளுடன் மட்டுமே ஒரு வகையை உருவாக்கவும்
type UserInfo = Pick<User, 'name' | 'email'>;

// ஐடியைத் தவிர பயனரின் அனைத்து பண்புகளுடன் ஒரு வகையை உருவாக்கவும்
type UserWithoutId = Omit<User, 'id'>;

TypeScript Node.js பயன்பாடுகளை சோதித்தல்

வலுவான மற்றும் நம்பகமான சேவையகப் பக்க பயன்பாடுகளை உருவாக்குவதில் சோதனை என்பது ஒரு முக்கிய பகுதியாகும். TypeScript ஐப் பயன்படுத்தும் போது, ​​மேலும் பயனுள்ள மற்றும் பராமரிக்கக்கூடிய சோதனைகளை எழுத நீங்கள் வகை அமைப்பைப் பயன்படுத்தலாம்.

Node.js க்கான பிரபலமான சோதனை கட்டமைப்புகளில் ஜெஸ்ட் மற்றும் மோச்சா ஆகியவை அடங்கும். இந்த கட்டமைப்புகள் அலகு சோதனைகள், ஒருங்கிணைப்பு சோதனைகள் மற்றும் இறுதி முதல் இறுதி சோதனைகளை எழுதுவதற்கான பல்வேறு அம்சங்களை வழங்குகின்றன.

ஜெஸ்ட்டைப் பயன்படுத்தி ஒரு அலகு சோதனையின் எடுத்துக்காட்டு இங்கே:

// src/utils.ts
export function add(a: number, b: number): number {
  return a + b;
}

// test/utils.test.ts
import { add } from '../src/utils';

describe('add', () => {
  it('இரண்டு எண்களின் தொகையை வழங்க வேண்டும்', () => {
    expect(add(1, 2)).toBe(3);
  });

  it('எதிர்மறை எண்களை கையாள வேண்டும்', ()nத () => {
    expect(add(-1, 2)).toBe(1);
  });
});

இந்த எடுத்துக்காட்டில், add செயல்பாடு ஜெஸ்ட்டைப் பயன்படுத்தி சோதிக்கப்படுகிறது. describe பிளாக் தொடர்புடைய சோதனைகளை ஒன்றாகக் குழுவாக்குகிறது. it பிளாக்குகள் தனிப்பட்ட சோதனை நிகழ்வுகளை வரையறுக்கின்றன. குறியீட்டின் நடத்தை பற்றிய கூற்றுக்களைச் செய்ய expect செயல்பாடு பயன்படுத்தப்படுகிறது.

TypeScript குறியீட்டிற்கான சோதனைகளை எழுதும் போது, ​​உங்கள் சோதனைகள் சாத்தியமான அனைத்து வகை காட்சிகளையும் உள்ளடக்கும் என்பதை உறுதிப்படுத்துவது முக்கியம். வெவ்வேறு வகையான உள்ளீடுகளுடன் சோதனை செய்வது, பூஜ்ஜியம் மற்றும் வரையறுக்கப்படாத மதிப்புகளுடன் சோதனை செய்வது மற்றும் தவறான தரவுடன் சோதனை செய்வது ஆகியவை இதில் அடங்கும்.

TypeScript Node.js மேம்பாட்டிற்கான சிறந்த நடைமுறைகள்

உங்கள் TypeScript Node.js திட்டங்கள் நன்கு கட்டமைக்கப்பட்டுள்ளன, பராமரிக்கக்கூடியவை மற்றும் அளவிடக்கூடியவை என்பதை உறுதிப்படுத்த, சில சிறந்த நடைமுறைகளைப் பின்பற்றுவது முக்கியம்:

• கண்டிப்பான பயன்முறையைப் பயன்படுத்தவும்: கடுமையான வகை சரிபார்ப்பை செயல்படுத்தவும் ஆரம்பத்தில் சாத்தியமான பிழைகளைக் பிடிக்கவும் உங்கள் tsconfig.json கோப்பில் கண்டிப்பான பயன்முறையை இயக்கவும்.
• தெளிவான இடைமுகங்கள் மற்றும் வகைகளை வரையறுக்கவும்: உங்கள் தரவின் கட்டமைப்பை வரையறுக்கவும் உங்கள் பயன்பாடு முழுவதும் வகை பாதுகாப்பை உறுதிப்படுத்தவும் இடைமுகங்கள் மற்றும் வகைகளைப் பயன்படுத்தவும்.
• பொதுவானவற்றைப் பயன்படுத்தவும்: வகை பாதுகாப்பை தியாகம் செய்யாமல் வெவ்வேறு வகைகளுடன் வேலை செய்யக்கூடிய மறுபயன்பாட்டு குறியீட்டை எழுத பொதுவானவற்றைப் பயன்படுத்தவும்.
• வேறுபடுத்தப்பட்ட சங்கங்களைப் பயன்படுத்தவும்: பல வெவ்வேறு வகைகளில் ஒன்றாக இருக்கக்கூடிய மதிப்புகளைக் குறிக்க வேறுபடுத்தப்பட்ட சங்கங்களைப் பயன்படுத்தவும்.
• விரிவான சோதனைகளை எழுதுங்கள்: உங்கள் குறியீடு சரியாக வேலை செய்கிறதா என்பதையும் உங்கள் பயன்பாடு நிலையானதாக இருக்கிறதா என்பதையும் உறுதிப்படுத்த அலகு சோதனைகள், ஒருங்கிணைப்பு சோதனைகள் மற்றும் இறுதி முதல் இறுதி சோதனைகளை எழுதுங்கள்.
• நிலையான குறியீட்டு பாணியைப் பின்பற்றவும்: நிலையான குறியீட்டு பாணியை செயல்படுத்தவும் சாத்தியமான பிழைகளைக் பிடிக்கவும் பிரெட்டியர் போன்ற குறியீடு வடிவமைப்பாளரையும் ESLint போன்ற லிண்டரையும் பயன்படுத்தவும். ஒரு நிலையான குறியீட்டு தளத்தை பராமரிக்க ஒரு குழுவுடன் பணிபுரியும் போது இது மிகவும் முக்கியமானது. ESLint மற்றும் பிரெட்டியருக்கான பல உள்ளமைவு விருப்பங்கள் உள்ளன, அவை குழுவில் பகிரப்படலாம்.
• சார்பு ஊசி பயன்படுத்தவும்: சார்பு ஊசி என்பது உங்கள் குறியீட்டை பிரிக்கவும் அதை சோதிக்கக்கூடியதாக மாற்றவும் அனுமதிக்கும் ஒரு வடிவமைப்பு முறை. InversifyJS போன்ற கருவிகள் உங்கள் TypeScript Node.js திட்டங்களில் சார்பு ஊசி செயல்படுத்த உங்களுக்கு உதவலாம்.
• சரியான பிழை கையாளுதலை செயல்படுத்தவும்: விதிவிலக்குகளை நேர்த்தியாகப் பிடிக்கவும் கையாளவும் வலுவான பிழை கையாளுதலை செயல்படுத்தவும். உங்கள் பயன்பாடு செயலிழப்பதைத் தடுக்கவும் பயனுள்ள பிழைத்திருத்த தகவல்களை வழங்கவும் முயற்சி-பிடி தொகுதிகள் மற்றும் பிழை பதிவுசெய்தலைப் பயன்படுத்தவும்.
• ஒரு தொகுதி கட்டுப்படுத்தியைப் பயன்படுத்தவும்: உங்கள் குறியீட்டைத் தொகுக்க மற்றும் உற்பத்திக்காக அதை மேம்படுத்த Webpack அல்லது பார்சல் போன்ற தொகுதி கட்டுப்படுத்தியைப் பயன்படுத்தவும். பெரும்பாலும் முன்பக்க மேம்பாட்டுடன் தொடர்புடையதாக இருந்தாலும், தொகுதி கட்டுப்படுத்திகள் Node.js திட்டங்களுக்கும் பயனளிக்கும், குறிப்பாக ES தொகுதிகளுடன் பணிபுரியும் போது.
• ஒரு கட்டமைப்பைப் பயன்படுத்த கருத்தில் கொள்ளுங்கள்: TypeScript உடன் அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய Node.js பயன்பாடுகளை உருவாக்குவதற்கான ஒரு அமைப்பு மற்றும் மரபுகளை வழங்கும் NestJS அல்லது AdonisJS போன்ற கட்டமைப்புகளை ஆராயுங்கள். இந்த கட்டமைப்புகளில் சார்பு ஊசி, ரூட்டிங் மற்றும் இடைநிலை ஆதரவு போன்ற அம்சங்கள் அடங்கும்.

வரிசைப்படுத்தல் கருத்தில் கொள்ள வேண்டியவை

ஒரு TypeScript Node.js பயன்பாட்டை வரிசைப்படுத்துவது ஒரு நிலையான Node.js பயன்பாட்டை வரிசைப்படுத்துவதைப் போன்றது. இருப்பினும், சில கூடுதல் கருத்தில் கொள்ள வேண்டியவை உள்ளன:

• தொகுப்பு: வரிசைப்படுத்துவதற்கு முன்பு உங்கள் TypeScript குறியீட்டை JavaScript க்கு தொகுக்க வேண்டும். உங்கள் உருவாக்க செயல்முறையின் ஒரு பகுதியாக இதைச் செய்யலாம்.
• மூல வரைபடங்கள்: உற்பத்தியில் பிழைத்திருத்தத்தை எளிதாக்க உங்கள் வரிசைப்படுத்தல் தொகுப்பில் மூல வரைபடங்களைச் சேர்க்கவும்.
• சுற்றுச்சூழல் மாறிகள்: வெவ்வேறு சூழல்களுக்கு (எ.கா., மேம்பாடு, நிலைநிறுத்தம், உற்பத்தி) உங்கள் பயன்பாட்டை உள்ளமைக்க சுற்றுச்சூழல் மாறிகளைப் பயன்படுத்தவும். இது ஒரு நிலையான நடைமுறையாகும், ஆனால் தொகுக்கப்பட்ட குறியீட்டை கையாளும் போது இன்னும் முக்கியத்துவம் பெறுகிறது.

Node.js க்கான பிரபலமான வரிசைப்படுத்தல் தளங்களில் பின்வருவன அடங்கும்:

• AWS (Amazon Web Services): EC2, Elastic Beanstalk மற்றும் Lambda உட்பட Node.js பயன்பாடுகளை வரிசைப்படுத்துவதற்கான பல்வேறு சேவைகளை வழங்குகிறது.
• Google Cloud Platform (GCP): Compute Engine, App Engine மற்றும் Cloud Functions உட்பட AWS க்கு இதேபோன்ற சேவைகளை வழங்குகிறது.
• Microsoft Azure: Node.js பயன்பாடுகளை வரிசைப்படுத்துவதற்கான Virtual Machines, App Service மற்றும் Azure Functions போன்ற சேவைகளை வழங்குகிறது.
• Heroku: Node.js பயன்பாடுகளின் வரிசைப்படுத்தல் மற்றும் நிர்வாகத்தை எளிதாக்கும் ஒரு இயங்குதளம்-ஒரு-சேவை (PaaS).
• DigitalOcean: Node.js பயன்பாடுகளை வரிசைப்படுத்த நீங்கள் பயன்படுத்தக்கூடிய மெய்நிகர் தனிப்பட்ட சேவையகங்களை (VPS) வழங்குகிறது.
• Docker: உங்கள் பயன்பாட்டையும் அதன் சார்புகளையும் ஒரு கொள்கலனில் பேக் செய்ய உங்களை அனுமதிக்கும் ஒரு கொள்கலனாக்க தொழில்நுட்பம். டோக்கரை ஆதரிக்கும் எந்தவொரு சூழலிலும் உங்கள் பயன்பாட்டை வரிசைப்படுத்துவதை இது எளிதாக்குகிறது.

முடிவு

Node.js உடன் வலுவான மற்றும் அளவிடக்கூடிய சேவையகப் பக்க பயன்பாடுகளை உருவாக்குவதற்கு பாரம்பரிய JavaScript ஐ விட TypeScript ஒரு குறிப்பிடத்தக்க மேம்பாட்டை வழங்குகிறது. வகை பாதுகாப்பு, மேம்படுத்தப்பட்ட IDE ஆதரவு மற்றும் மேம்பட்ட மொழி அம்சங்களைப் பயன்படுத்துவதன் மூலம், நீங்கள் பராமரிக்கக்கூடிய, நம்பகமான மற்றும் திறமையான பின்தள அமைப்புகளை உருவாக்கலாம். TypeScript ஐ ஏற்றுக்கொள்வதில் ஒரு கற்றல் வளைவு இருந்தாலும், குறியீடு தரம் மற்றும் டெவலப்பர் உற்பத்தித்திறன் ஆகியவற்றின் அடிப்படையில் நீண்டகால நன்மைகள் அதை ஒரு பயனுள்ள முதலீடாக ஆக்குகின்றன. நன்கு கட்டமைக்கப்பட்ட மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளுக்கான தேவை தொடர்ந்து அதிகரித்து வருவதால், TypeScript உலகளவில் சேவையகப் பக்க டெவலப்பர்களுக்கு ஒரு முக்கியமான கருவியாக மாறும் என்று எதிர்பார்க்கப்படுகிறது.